ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ Symbol.wellKnown: ಅಂತರ್ನಿರ್ಮಿತ ಸಿಂಬಲ್ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ECMAScript 2015 (ES6) ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಬಲ್‌ಗಳು, ಒಂದು ವಿಶಿಷ್ಟ ಮತ್ತು ಬದಲಾಗದ ಪ್ರಿಮಿಟಿವ್ ಟೈಪ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇವುಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಕೀಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಅವುಗಳ ಮೂಲಭೂತ ಬಳಕೆಯ ಹೊರತಾಗಿ, ಸಿಂಬಲ್‌ಗಳು ವೆಲ್-ನೋನ್ ಸಿಂಬಲ್ಸ್ (well-known symbols) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಮೂಲಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಒಂದು ಶಕ್ತಿಯುತ ವ್ಯವಸ್ಥೆಯನ್ನು ನೀಡುತ್ತವೆ. ಈ ಸಿಂಬಲ್‌ಗಳು Symbol ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಟ್ಯಾಟಿಕ್ ಪ್ರಾಪರ್ಟಿಗಳಾಗಿ (ಉದಾ., Symbol.iterator, Symbol.toStringTag) ಮೊದಲೇ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಿಂಬಲ್ ಮೌಲ್ಯಗಳಾಗಿವೆ. ಅವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್‌ಗಳು ಬಳಸುವ ನಿರ್ದಿಷ್ಟ ಆಂತರಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಈ ಸಿಂಬಲ್‌ಗಳನ್ನು ಕೀಗಳಾಗಿ ಬಳಸಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ಡೀಫಾಲ್ಟ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಡವಳಿಕೆಗಳನ್ನು ತಡೆದು ತಿದ್ದಬಹುದು (override). ಈ ಸಾಮರ್ಥ್ಯವು ಉನ್ನತ ಮಟ್ಟದ ನಿಯಂತ್ರಣ ಮತ್ತು ಕಸ್ಟಮೈಸೇಶನ್ ಅನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುತ್ತದೆ, ಇದರಿಂದ ನೀವು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಶಕ್ತಿಯುತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.

ಸಿಂಬಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ವೆಲ್-ನೋನ್ ಸಿಂಬಲ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿಯುವ ಮೊದಲು, ಸಿಂಬಲ್‌ಗಳ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ಸಿಂಬಲ್‌ಗಳು ಎಂದರೇನು?

ಸಿಂಬಲ್‌ಗಳು ವಿಶಿಷ್ಟ ಮತ್ತು ಬದಲಾಗದ ಡೇಟಾ ಟೈಪ್‌ಗಳಾಗಿವೆ. ಒಂದೇ ವಿವರಣೆಯೊಂದಿಗೆ ರಚಿಸಿದರೂ ಸಹ, ಪ್ರತಿಯೊಂದು ಸಿಂಬಲ್ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲಾಗಿದೆ. ಇದು ಅವುಗಳನ್ನು ಪ್ರೈವೇಟ್-ರೀತಿಯ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರಚಿಸಲು ಅಥವಾ ವಿಶಿಷ್ಟ ಗುರುತಿಸುವಿಕೆಗಳಾಗಿ ಬಳಸಲು ಸೂಕ್ತವಾಗಿಸುತ್ತದೆ.

            const sym1 = Symbol();
const sym2 = Symbol("description");
const sym3 = Symbol("description");

console.log(sym1 === sym2); // false
console.log(sym2 === sym3); // false
            

              
                Copy
              
            
          

ಸಿಂಬಲ್‌ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

• ವಿಶಿಷ್ಟತೆ: ಪ್ರಾಪರ್ಟಿ ಕೀಗಳು ವಿಶಿಷ್ಟವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಹೆಸರಿನ ಸಂಘರ್ಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
• ಗೌಪ್ಯತೆ: ಸಿಂಬಲ್‌ಗಳು ಡಿಫಾಲ್ಟ್ ಆಗಿ ಎಣಿಕೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ (not enumerable), ಇದು ಒಂದು ಮಟ್ಟದ ಮಾಹಿತಿ ಮರೆಮಾಚುವಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ (ಆದರೂ ಕಟ್ಟುನಿಟ್ಟಾದ ಅರ್ಥದಲ್ಲಿ ನಿಜವಾದ ಗೌಪ್ಯತೆ ಅಲ್ಲ).
• ವಿಸ್ತರಣೀಯತೆ: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಅಡ್ಡಿಪಡಿಸದೆ ಅಂತರ್ನಿರ್ಮಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

Symbol.wellKnown ಗೆ ಪರಿಚಯ

Symbol.wellKnown ಎನ್ನುವುದು ಒಂದೇ ಪ್ರಾಪರ್ಟಿ ಅಲ್ಲ, ಆದರೆ ಇದು Symbol ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಟ್ಯಾಟಿಕ್ ಪ್ರಾಪರ್ಟಿಗಳಿಗಾಗಿ ಬಳಸುವ ಒಂದು ಸಾಮೂಹಿಕ ಪದವಾಗಿದೆ. ಇವು ವಿಶೇಷ, ಭಾಷಾ-ಮಟ್ಟದ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಈ ಸಿಂಬಲ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್‌ನ ಆಂತರಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹುಕ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕೆಲವು Symbol.wellKnown ಪ್ರಾಪರ್ಟಿಗಳ ವಿವರಣೆ ಇಲ್ಲಿದೆ:

• Symbol.iterator
• Symbol.toStringTag
• Symbol.toPrimitive
• Symbol.hasInstance
• Symbol.species
• ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಸಿಂಬಲ್‌ಗಳು: Symbol.match, Symbol.replace, Symbol.search, Symbol.split

ನಿರ್ದಿಷ್ಟ Symbol.wellKnown ಪ್ರಾಪರ್ಟಿಗಳ ಆಳವಾದ ನೋಟ

1. Symbol.iterator: ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಇಟರೇಬಲ್ ಮಾಡುವುದು

Symbol.iterator ಸಿಂಬಲ್ ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಇಟರೇಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಒಂದು ಆಬ್ಜೆಕ್ಟ್ Symbol.iterator ಕೀಲಿಯೊಂದಿಗೆ ಪ್ರಾಪರ್ಟಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ ಮತ್ತು ಅದರ ಮೌಲ್ಯವು ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಆಗಿದ್ದರೆ, ಆ ಆಬ್ಜೆಕ್ಟ್ ಇಟರೇಬಲ್ ಆಗಿರುತ್ತದೆ. ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ next() ಮೆಥಡ್ ಇರಬೇಕು, ಅದು ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: value (ಸರಣಿಯಲ್ಲಿನ ಮುಂದಿನ ಮೌಲ್ಯ) ಮತ್ತು done (ಇಟರೇಷನ್ ಪೂರ್ಣಗೊಂಡಿದೆಯೇ ಎಂದು ಸೂಚಿಸುವ ಬೂಲಿಯನ್).

ಬಳಕೆಯ ಸಂದರ್ಭ: ನಿಮ್ಮ ಡೇಟಾ ರಚನೆಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಇಟರೇಷನ್ ಲಾಜಿಕ್. ನೀವು ಒಂದು ಕಸ್ಟಮ್ ಡೇಟಾ ರಚನೆಯನ್ನು, ಉದಾಹರಣೆಗೆ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್, ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. Symbol.iterator ಅನ್ನು ಅಳವಡಿಸುವ ಮೂಲಕ, ನೀವು ಅದನ್ನು for...of ಲೂಪ್‌ಗಳು, ಸ್ಪ್ರೆಡ್ ಸಿಂಟ್ಯಾಕ್ಸ್ (...), ಮತ್ತು ಇಟರೇಟರ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ಇತರ ರಚನೆಗಳೊಂದಿಗೆ ಬಳಸಲು ಅನುಮತಿಸುತ್ತೀರಿ.

ಉದಾಹರಣೆ:

            const myCollection = {
  items: [1, 2, 3, 4, 5],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.items.length) {
          return { value: this.items[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

for (const item of myCollection) {
  console.log(item);
}

console.log([...myCollection]); // [1, 2, 3, 4, 5]
            

              
                Copy
              
            
          

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: Symbol.iterator ಅನ್ನು ಒಂದು ಸಂಗ್ರಹದಲ್ಲಿನ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು 'ಪ್ರೋಟೋಕಾಲ್' ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಂತೆ ಯೋಚಿಸಿ, ಹೇಗೆ ಬೇರೆ ಬೇರೆ ಸಂಸ್ಕೃತಿಗಳು ಚಹಾ ಬಡಿಸಲು ವಿಭಿನ್ನ ಪದ್ಧತಿಗಳನ್ನು ಹೊಂದಿರಬಹುದೋ ಹಾಗೆ - ಪ್ರತಿಯೊಂದು ಸಂಸ್ಕೃತಿಯೂ ತನ್ನದೇ ಆದ 'ಇಟರೇಷನ್' ವಿಧಾನವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

2. Symbol.toStringTag: toString() ನಿರೂಪಣೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು

Symbol.toStringTag ಸಿಂಬಲ್ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವಾಗಿದೆ, ಇದನ್ನು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಮೇಲೆ toString() ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗ ಟ್ಯಾಗ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಡಿಫಾಲ್ಟ್ ಆಗಿ, Object.prototype.toString.call(myObject) ಅನ್ನು ಕರೆದರೆ [object Object] ಎಂದು ಹಿಂತಿರುಗುತ್ತದೆ. Symbol.toStringTag ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ಈ ನಿರೂಪಣೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು.

ಬಳಕೆಯ ಸಂದರ್ಭ: ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುವಾಗ ಹೆಚ್ಚು ಮಾಹಿತಿಪೂರ್ಣ ಔಟ್‌ಪುಟ್ ನೀಡುವುದು. ಇದು ವಿಶೇಷವಾಗಿ ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಲಾಗಿಂಗ್‌ಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ, ನಿಮ್ಮ ಕಸ್ಟಮ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪ್ರಕಾರವನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

            class MyClass {
  constructor(name) {
    this.name = name;
  }
  get [Symbol.toStringTag]() {
    return 'MyClassInstance';
  }
}

const myInstance = new MyClass('Example');

console.log(Object.prototype.toString.call(myInstance)); // [object MyClassInstance]
            

              
                Copy
              
            
          

Symbol.toStringTag ಇಲ್ಲದಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ [object Object] ಆಗಿರುತ್ತಿತ್ತು, ಇದರಿಂದ MyClass ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಕಷ್ಟವಾಗುತ್ತಿತ್ತು.

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: Symbol.toStringTag ಒಂದು ದೇಶದ ಧ್ವಜದಂತೆ - ಅಪರಿಚಿತ ವಸ್ತುವನ್ನು ಎದುರಿಸಿದಾಗ ಅದು ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಗುರುತನ್ನು ನೀಡುತ್ತದೆ. ಕೇವಲ "ವ್ಯಕ್ತಿ" ಎಂದು ಹೇಳುವ ಬದಲು, ಧ್ವಜವನ್ನು ನೋಡಿ "ಜಪಾನ್‌ನಿಂದ ಬಂದ ವ್ಯಕ್ತಿ" ಎಂದು ಹೇಳಬಹುದು.

3. Symbol.toPrimitive: ಟೈಪ್ ಪರಿವರ್ತನೆಯನ್ನು ನಿಯಂತ್ರಿಸುವುದು

Symbol.toPrimitive ಸಿಂಬಲ್ ಒಂದು ಫಂಕ್ಷನ್-ಮೌಲ್ಯದ ಪ್ರಾಪರ್ಟಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇದನ್ನು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರಿಮಿಟಿವ್ ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಕರೆಯಲಾಗುತ್ತದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರಿಮಿಟಿವ್‌ಗೆ ಪರಿವರ್ತಿಸಬೇಕಾದಾಗ, ಉದಾಹರಣೆಗೆ +, == ನಂತಹ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಅಥವಾ ಫಂಕ್ಷನ್‌ಗೆ ಪ್ರಿಮಿಟಿವ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಬೇಕಾದಾಗ ಇದನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

ಬಳಕೆಯ ಸಂದರ್ಭ: ನಿಮ್ಮ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪ್ರಿಮಿಟಿವ್ ಮೌಲ್ಯಗಳು ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಸಿದಾಗ ಅವುಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಪರಿವರ್ತನೆ ಲಾಜಿಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್ ಒದಗಿಸುವ "ಹಿಂಟ್" (hint) ಆಧರಿಸಿ ನೀವು ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ನಂಬರ್ ಪರಿವರ್ತನೆಗೆ ಆದ್ಯತೆ ನೀಡಬಹುದು.

ಉದಾಹರಣೆ:

            const myObject = {
  value: 10,
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') {
      return this.value;
    } else if (hint === 'string') {
      return `The value is: ${this.value}`;
    } else {
      return this.value * 2;
    }
  }
};

console.log(Number(myObject));   // 10
console.log(String(myObject));   // The value is: 10
console.log(myObject + 5);      // 15  (default hint is number)
console.log(myObject == 10);     // true

const dateLike = {
 [Symbol.toPrimitive](hint) {
 return hint == "number" ? 10 : "hello!";
 }
};

console.log(dateLike + 5);
console.log(dateLike == 10);

            

              
                Copy
              
            
          

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: Symbol.toPrimitive ಒಂದು ಸಾರ್ವತ್ರಿಕ ಅನುವಾದಕನಂತೆ. ಇದು ನಿಮ್ಮ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸಂದರ್ಭಕ್ಕೆ ಅನುಗುಣವಾಗಿ ವಿಭಿನ್ನ "ಭಾಷೆಗಳಲ್ಲಿ" (ಪ್ರಿಮಿಟಿವ್ ಟೈಪ್‌ಗಳು) "ಮಾತನಾಡಲು" ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದರಿಂದ ಅದು ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅರ್ಥವಾಗುತ್ತದೆ.

4. Symbol.hasInstance: instanceof ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು

Symbol.hasInstance ಸಿಂಬಲ್ ಒಂದು ಮೆಥಡ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಅದು ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಆಬ್ಜೆಕ್ಟ್ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ತನ್ನ ಇನ್‌ಸ್ಟಾನ್ಸ್‌ ಎಂದು ಗುರುತಿಸುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದನ್ನು instanceof ಆಪರೇಟರ್ ಬಳಸುತ್ತದೆ.

ಬಳಕೆಯ ಸಂದರ್ಭ: ಕಸ್ಟಮ್ ಕ್ಲಾಸ್‌ಗಳು ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಡೀಫಾಲ್ಟ್ instanceof ನಡವಳಿಕೆಯನ್ನು ತಿದ್ದಿ ಬರೆಯಿರಿ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪ್ರೊಟೋಟೈಪ್ ಚೈನ್ ಪರಿಶೀಲನೆಗಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಅಥವಾ ಸೂಕ್ಷ್ಮವಾದ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಪರಿಶೀಲನೆ ಅಗತ್ಯವಿದ್ದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ:

            class MyClass {
  static [Symbol.hasInstance](obj) {
    return !!obj.isMyClassInstance;
  }
}

const myInstance = { isMyClassInstance: true };
const notMyInstance = {};

console.log(myInstance instanceof MyClass);    // true
console.log(notMyInstance instanceof MyClass); // false
            

              
                Copy
              
            
          

ಸಾಮಾನ್ಯವಾಗಿ, instanceof ಪ್ರೊಟೋಟೈಪ್ ಚೈನ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು isMyClassInstance ಪ್ರಾಪರ್ಟಿಯ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸಲು ಅದನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ್ದೇವೆ.

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: Symbol.hasInstance ಒಂದು ಗಡಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಯಂತೆ. ಇದು ನಿರ್ದಿಷ್ಟ ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ಯಾರು "ನಾಗರಿಕ" (ಒಂದು ಕ್ಲಾಸ್‌ನ ಇನ್‌ಸ್ಟಾನ್ಸ್) ಎಂದು ಪರಿಗಣಿಸಲು ಅರ್ಹರು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಮತ್ತು ಡೀಫಾಲ್ಟ್ ನಿಯಮಗಳನ್ನು ತಿದ್ದಿ ಬರೆಯುತ್ತದೆ.

5. Symbol.species: ವ್ಯುತ್ಪನ್ನ (Derived) ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಯ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರುವುದು

Symbol.species ಸಿಂಬಲ್ ಅನ್ನು ವ್ಯುತ್ಪನ್ನ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಬಳಸಬೇಕಾದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಹೊಸ ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೆಥಡ್‌ಗಳಿಂದ (ಉದಾ., Array.prototype.slice, Array.prototype.map, ಇತ್ಯಾದಿ) ಬಳಸಲಾಗುವ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸಬ್‌ಕ್ಲಾಸ್‌ಗಳು ತಿದ್ದಿ ಬರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ.

ಬಳಕೆಯ ಸಂದರ್ಭ: ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದ ಮೆಥಡ್‌ಗಳಿಂದ ಹಿಂತಿರುಗಿಸಲ್ಪಡುವ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರಕಾರವನ್ನು ನಿಯಂತ್ರಿಸಿ. ನೀವು ಕಸ್ಟಮ್ ಅರೇ-ರೀತಿಯ ಕ್ಲಾಸ್ ಹೊಂದಿರುವಾಗ ಮತ್ತು slice ನಂತಹ ಮೆಥಡ್‌ಗಳು ಅಂತರ್ನಿರ್ಮಿತ Array ಕ್ಲಾಸ್ ಬದಲಿಗೆ ನಿಮ್ಮ ಕಸ್ಟಮ್ ಕ್ಲಾಸ್‌ನ ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕೆಂದು ನೀವು ಬಯಸಿದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ:

            class MyArray extends Array {
  static get [Symbol.species]() {
    return Array;
  }
}

const myArray = new MyArray(1, 2, 3);
const slicedArray = myArray.slice(1);

console.log(slicedArray instanceof MyArray); // false
console.log(slicedArray instanceof Array); // true

class MyArray2 extends Array {
 static get [Symbol.species]() {
 return MyArray2;
 }
}

const myArray2 = new MyArray2(1, 2, 3);
const slicedArray2 = myArray2.slice(1);

console.log(slicedArray2 instanceof MyArray2); // true
console.log(slicedArray2 instanceof Array); // true

            

              
                Copy
              
            
          

Symbol.species ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, slice Array ನ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅದನ್ನು ತಿದ್ದಿ ಬರೆಯುವ ಮೂಲಕ, ನಾವು ಅದು MyArray ನ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತೇವೆ.

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: Symbol.species ಜನ್ಮದಿಂದ ಪೌರತ್ವದಂತೆ. ಇದು ಒಂದು ಮಗು ಆಬ್ಜೆಕ್ಟ್ ಯಾವ "ದೇಶಕ್ಕೆ" (ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್) ಸೇರಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಅದು ಬೇರೆ "ರಾಷ್ಟ್ರೀಯತೆಯ" ಪೋಷಕರಿಂದ ಜನಿಸಿದ್ದರೂ ಸಹ.

6. ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಸಿಂಬಲ್‌ಗಳು: Symbol.match, Symbol.replace, Symbol.search, Symbol.split

ಈ ಸಿಂಬಲ್‌ಗಳು (Symbol.match, Symbol.replace, Symbol.search, ಮತ್ತು Symbol.split) ಸ್ಟ್ರಿಂಗ್ ಮೆಥಡ್‌ಗಳನ್ನು ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಬಳಸಿದಾಗ ಅವುಗಳ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಈ ಮೆಥಡ್‌ಗಳು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನಿಮ್ಮ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಈ ಸಿಂಬಲ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ಅವುಗಳನ್ನು ಈ ಸ್ಟ್ರಿಂಗ್ ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ಬಳಸಿದಾಗ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಂತೆ ವರ್ತಿಸುವಂತೆ ಮಾಡಬಹುದು.

ಬಳಕೆಯ ಸಂದರ್ಭ: ಕಸ್ಟಮ್ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಅಥವಾ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಲಾಜಿಕ್ ಅನ್ನು ರಚಿಸಿ. ಉದಾಹರಣೆಗೆ, ನೀವು ವಿಶೇಷ ರೀತಿಯ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅದು String.prototype.replace ಮೆಥಡ್‌ನೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

ಉದಾಹರಣೆ:

            const myPattern = {
  [Symbol.match](string) {
    const index = string.indexOf('custom');
    return index >= 0 ? [ 'custom' ] : null;
  }
};

console.log('This is a custom string'.match(myPattern)); // [ 'custom' ]
console.log('This is a regular string'.match(myPattern)); // null

const myReplacer = {
  [Symbol.replace](string, replacement) {
    return string.replace(/custom/g, replacement);
  }
};

console.log('This is a custom string'.replace(myReplacer, 'modified')); // This is a modified string

            

              
                Copy
              
            
          

ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಾದೃಶ್ಯ: ಈ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಸಿಂಬಲ್‌ಗಳು ವಿಭಿನ್ನ ಭಾಷೆಗಳಿಗೆ ಸ್ಥಳೀಯ ಅನುವಾದಕರನ್ನು ಹೊಂದುವಂತಿವೆ. ಅವು ಸ್ಟ್ರಿಂಗ್ ಮೆಥಡ್‌ಗಳಿಗೆ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲದ ಕಸ್ಟಮ್ "ಭಾಷೆಗಳು" ಅಥವಾ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅವುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ.

ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಲೈಬ್ರರಿ ಅಭಿವೃದ್ಧಿ: ವಿಸ್ತರಿಸಬಲ್ಲ ಮತ್ತು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದಾದ ಲೈಬ್ರರಿಗಳನ್ನು ರಚಿಸಲು Symbol.wellKnown ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಬಳಸಿ.
• ಡೇಟಾ ರಚನೆಗಳು: ನಿಮ್ಮ ಡೇಟಾ ರಚನೆಗಳಿಗೆ ಕಸ್ಟಮ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿ, ಅವುಗಳನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರಚನೆಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಬಳಸುವಂತೆ ಮಾಡಿ.
• ಡೀಬಗ್ಗಿಂಗ್: ನಿಮ್ಮ ಡೀಬಗ್ಗಿಂಗ್ ಔಟ್‌ಪುಟ್‌ನ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು Symbol.toStringTag ಅನ್ನು ಬಳಸಿ.
• ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು APIಗಳು: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು API ಗಳೊಂದಿಗೆ ತಡೆರಹಿತ ಏಕೀಕರಣವನ್ನು ರಚಿಸಲು ಈ ಸಿಂಬಲ್‌ಗಳನ್ನು ಬಳಸಿ.

ಪರಿಗಣನೆಗಳು ಮತ್ತು ಎಚ್ಚರಿಕೆಗಳು

• ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ: ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳು ಸಿಂಬಲ್‌ಗಳು ಮತ್ತು Symbol.wellKnown ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆಯಾದರೂ, ಹಳೆಯ ಪರಿಸರಗಳಿಗಾಗಿ ನೀವು ಸೂಕ್ತವಾದ ಪಾಲಿಫಿಲ್‌ಗಳನ್ನು ಹೊಂದಿರುವಿರೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಸಂಕೀರ್ಣತೆ: ಈ ವೈಶಿಷ್ಟ್ಯಗಳ ಅತಿಯಾದ ಬಳಕೆಯು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು. ಅವುಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸಿ ಮತ್ತು ನಿಮ್ಮ ಕಸ್ಟಮೈಸೇಶನ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ದಾಖಲಿಸಿ.
• ಭದ್ರತೆ: ಸಿಂಬಲ್‌ಗಳು కొంత ಮಟ್ಟದ ಗೌಪ್ಯತೆಯನ್ನು ನೀಡುತ್ತವೆಯಾದರೂ, ಅವು ಒಂದು ದೋಷರಹಿತ ಭದ್ರತಾ ವ್ಯವಸ್ಥೆಯಲ್ಲ. ದೃಢನಿರ್ಧಾರದ ದಾಳಿಕೋರರು ರಿಫ್ಲೆಕ್ಷನ್ ಮೂಲಕ ಸಿಂಬಲ್-ಕೀ ಇರುವ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

ತೀರ್ಮಾನ

Symbol.wellKnown ಪ್ರಾಪರ್ಟಿಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಮತ್ತು ಅವುಗಳನ್ನು ಭಾಷೆಯ ಆಂತರಿಕ ಕಾರ್ಯವಿಧಾನಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಆಳವಾಗಿ ಸಂಯೋಜಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಈ ಸಿಂಬಲ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ, ವಿಸ್ತರಿಸಬಲ್ಲ ಮತ್ತು ದೃಢವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಸಂಭಾವ್ಯ ಸಂಕೀರ್ಣತೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಅವುಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸಲು ಮರೆಯದಿರಿ. ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಲ್ಲಿ ಹೊಸ ಸಾಧ್ಯತೆಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕೌಶಲ್ಯಗಳನ್ನು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಏರಿಸಲು ವೆಲ್-ನೋನ್ ಸಿಂಬಲ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಿ. ಯಾವಾಗಲೂ ಸ್ವಚ್ಛ, ಉತ್ತಮವಾಗಿ ದಾಖಲಿಸಲ್ಪಟ್ಟ ಕೋಡ್ ಬರೆಯಲು ಶ್ರಮಿಸಿ, ಅದು ಇತರರಿಗೆ (ಮತ್ತು ನಿಮ್ಮ ಭವಿಷ್ಯದ ನಿಮಗೆ) ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿರುತ್ತದೆ. ಈ ಸುಧಾರಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಕಲ್ಪನೆಗಳಿಂದ ಇತರರು ಕಲಿಯಲು ಮತ್ತು ಪ್ರಯೋಜನ ಪಡೆಯಲು ಸಹಾಯ ಮಾಡಲು ಓಪನ್-ಸೋರ್ಸ್ ಯೋಜನೆಗಳಿಗೆ ಕೊಡುಗೆ ನೀಡುವುದನ್ನು ಅಥವಾ ನಿಮ್ಮ ಜ್ಞಾನವನ್ನು ಸಮುದಾಯದೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳುವುದನ್ನು ಪರಿಗಣಿಸಿ.